package com.mamingchao.basic.swardToOffer.three;

import org.bouncycastle.util.Arrays;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * 题目：小红标字母
 *
 * 小红拿到一个字符串，她可以做任意次以下的操作
 *     标记这个字符串两个位置相邻的字母，并且这两个字母必须满足以下条件才可以标记：两个字母相同或者两个字母在字母表中相邻。
 *     标记上，小红就可以获得这两个字母的分数；
 *
 * 每个字母的分数时不通的，'a' 可以获得1分，'b' 可以获得2分，一次类推，'z'可以获得26分
 *
 * 我们规定，已经被标记的字母，无法被重复标记
 *
 * 输入描述：
 *     输入一个只包含小写字母的非空字符串s
 *     1<= len(s) <=200000
 *
 * 示例：
 *     输入 abdbb
 *     输出 7
 *     说明 a和b标记获得3分，b和b标记获得4分，总共7分
 */
public class MakerAlpha {

    public static void main(String[] args) {
        final String input = "adddfabcdehh";
        char[] arr = input.toCharArray();
        int startIndex = 0;
        int result = 0;

        long start = System.currentTimeMillis();
        while (startIndex < arr.length -1) {
            GroupInner group = getSliceByGroup(arr, startIndex);
            result  += calMaxValueByPhase(group.getGroup());
            startIndex = group.getStartIndex();
        }
        long end = System.currentTimeMillis();

        System.out.println((end - start) + " " +  result);

        long start1 = System.currentTimeMillis();
        int result1 = MarkLetters.getMaxScore(input);
        long end1 = System.currentTimeMillis();

        System.out.println((end1 - start1) + " " +  result1);
    }

    public static GroupInner getSliceByGroup(char[] arr, int startIndex){
        // base case
        if (Objects.isNull(arr) || arr.length == 0) {
            return new GroupInner(new char[0], 0);
        }
        List<Character> group = new ArrayList<>();

        // 原本的想法是，字符串中每一段 连着的、可用计算积分的子串，都是在一个group中
        // 然后计算每个group下的的最优，再累加
        boolean isGroup = false;
        while (startIndex < arr.length-1) {
            if(Math.abs(arr[startIndex] - arr[startIndex+1]) < 2) {
                isGroup = true;
                group.add(arr[startIndex]);
            } else if (isGroup){
                group.add(arr[startIndex]);
                break;
            }
            startIndex ++;
        }

        if (startIndex == arr.length -1 && isGroup) {
            group.add(arr[startIndex]);
        }

        StringBuilder sb = new StringBuilder();
        for (Character c : group) {
            sb.append(c);
        }
        char[] result = sb.toString().toCharArray();
        return new GroupInner(result, startIndex + 1);
    }

    /**
     * 计算每组的积分
     * @param slice
     * @return
     */
    private static int calMaxValueByPhase(char[] slice){
        // base case
        if (Objects.isNull(slice) || slice.length < 2) {
            return 0;
        }

        // 如果是奇数个
        if (slice.length % 2 == 1) {
            int case1 = calculate(Arrays.copyOfRange(slice,1, slice.length));
            int case2 = calculate(Arrays.copyOfRange(slice,0,slice.length -1));
            return Math.max(case1, case2);
        } else {
            // 如果是偶数
            return calculate(slice);
        }
    }

    /**
     * 计算偶数配对字母数组的积分
     * @param slice
     * @return
     */
    private static int calculate(char[] slice) {
        if (Objects.isNull(slice) || slice.length % 2 != 0) {
            return 0;
        }
        int result = 0 ;
        for (int i = 0; i < slice.length; i++) {
            result += getValue(slice[i]);
        }

        return result;
    }

    private static int getValue(char alpha) {
        return  alpha -96;
    }

    private static class GroupInner{
        private char[] group;
        private  int startIndex;

        public GroupInner(char[] group, int startIndex) {
            this.group = group;
            this.startIndex = startIndex;
        }

        public char[] getGroup() {
            return group;
        }

        public void setGroup(char[] group) {
            this.group = group;
        }

        public int getStartIndex() {
            return startIndex;
        }

        public void setStartIndex(int startIndex) {
            this.startIndex = startIndex;
        }
    }
}
